// /**
//  *	@define:hjc -> UI -> 矢量绘制
//  */

// namespace ui {


// 	let $dashArray: number[] = [];						//(当前绘图)虚线样式
// 	// let $pFrom: egret.Point = new egret.Point();		//(当前绘图)开始点
// 	// let $pTo: egret.Point = new egret.Point();			//(当前绘图)结束点

// 	function _reset(shape: egret.Shape, params: hjc.TDraw): egret.Graphics {
// 		if (notEmpty(params)) {
// 			shape.graphics.lineStyle(numeric(params.thickness) ? params.thickness : $thickness,
// 				numeric(params.lineColor) ? params.lineColor : $lineColor,
// 				numeric(params.lineAlpha) ? params.lineAlpha : $lineAlpha);
// 			shape.graphics.beginFill(numeric(params.fillColor) ? params.fillColor : $fillColor,
// 				numeric(params.fillAlpha) ? params.fillAlpha : $fillAlpha);
// 		}
// 		return shape.graphics;
// 	}

// 	/**
// 	 * 重置矢量绘图线条颜色
// 	 * @param lineColor 线条颜色
// 	 * @return ui模块
// 	 */
// 	export function resetLineColor(lineColor: number): any { $lineColor = lineColor; return ui; }

// 	/**
// 	 * 重置矢量绘图填充颜色
// 	 * @param fillColor 线条颜色
// 	 * @return ui模块
// 	 */
// 	export function resetFillColor(fillColor: number): any { $fillColor = fillColor; return ui; }

// 	/**
// 	 * 重置矢量绘图线条透明度
// 	 * @param lineAlpha 线条透明度
// 	 * @return ui模块
// 	 */
// 	export function resetLineAlpha(lineAlpha: number): any { $lineAlpha = lineAlpha; return ui; }

// 	/**
// 	 * 重置矢量绘图填充透明度
// 	 * @param fillAlpha 填充透明度
// 	 * @return ui模块
// 	 */
// 	export function resetFillAlpha(fillAlpha: number): any { $fillAlpha = fillAlpha; return ui; }

// 	/**
// 	 * 重置矢量绘图线条粗细
// 	 * @param thickness 线条粗细
// 	 * @return ui模块
// 	 */
// 	export function resetThinkness(thickness: number): any { $thickness = thickness; return ui; }

// 	/**
// 	 * 创建或者重置矩形绘图
// 	 * @param params 创建或者重置参数
// 	 * @param rect 重置矩形绘图
// 	 * @return 创建或者重置结果
// 	 */
// 	export function _drawRect(params: hjc.TDraw, rect?: egret.Shape): egret.Shape {
// 		let [shape, w, h] = [null, params.width, params.height];
// 		if (rect) {
// 			shape = rect;
// 			w = utils.num(w, shape.width);
// 			h = utils.num(h, shape.height);
// 			shape.graphics.clear();
// 		} else {
// 			shape = new egret.Shape();
// 			w = utils.num(w, hjc.UI.Default.WIDTH);
// 			h = utils.num(h, hjc.UI.Default.HEIGHT);
// 		}
// 		_reset(shape, params).drawRect(0, 0, w, h);
// 		shape.graphics.endFill();
// 		return shape;
// 	}

// 	/**
// 	 * 创建或者重置圆形绘图
// 	 * @param params 创建或者重置参数
// 	 * @param circle 重置圆形绘图
// 	 * @return 创建或者重置结果
// 	 */
// 	export function _drawCircle(params: hjc.TDraw, circle?: egret.Shape): egret.Shape {
// 		let [shape, r] = [null, params.radius];
// 		if (circle) {
// 			shape = circle;
// 			r = utils.num(r, shape.width / 2);
// 			shape.graphics.clear();
// 		} else {
// 			shape = new egret.Shape();
// 			r = utils.num(r, hjc.UI.Default.RADIUS);
// 		}
// 		_reset(shape, params).drawCircle(0, 0, r);
// 		shape.graphics.endFill();
// 		return shape;
// 	}

// 	/**
// 	 * 创建或者重置网格
// 	 * @param params 创建或者重置参数
// 	 * @param grids 重置网格绘图
// 	 * @return 创建或者重置结果
// 	 */
// 	export function _drawGrids(params: hjc.TDraw, grids?: egret.Shape): egret.Shape {
// 		let [shape, rowNum, colNum, gap] = [null, params.rowNum, params.colNum, params.gap];
// 		console.log(params);
// 		if (grids) {
// 			shape = grids;
// 			shape.graphics.clear();
// 		} else shape = new egret.Shape();
// 		_reset(shape, params);
// 		for (let row = 0; row <= rowNum; row++) {
// 			shape.graphics.moveTo(0, row * gap);
// 			shape.graphics.lineTo(colNum * gap, row * gap);
// 			shape.graphics.endFill();
// 		}
// 		for (let col = 0; col <= colNum; col++) {
// 			shape.graphics.moveTo(col * gap, 0);
// 			shape.graphics.lineTo(col * gap, gap * rowNum);
// 			shape.graphics.endFill();
// 		}
// 		shape.graphics.endFill();
// 		return shape;
// 	}

// 	// /**
// 	//  * 创建或者重置直线绘图
// 	//  * @param params 创建或者重置参数
// 	//  * @param line 重置直线绘图
// 	//  * @return 创建或者重置结果
// 	//  */
// 	// export function drawLine(params: hjc.TDraw, line?: egret.Shape): egret.Shape {
// 	// 	let [shape, x1, y1, x2, y2] = [null, 0, 0, 100, 100];
// 	// 	if (line) {
// 	// 		shape = line;
// 	// 		shape.graphics.clear();
// 	// 	} else shape = new egret.Shape();
// 	// 	if (params.p1 instanceof egret.Point) {
// 	// 		x1 = params.p1.x; y1 = params.p1.y;
// 	// 		if (params.p2 instanceof egret.Point) { x2 = params.p2.x; y2 = params.p2.y; }
// 	// 		//else if // 点角方式
// 	// 		else console.warn('不支持的绘制直线方式');
// 	// 	} else if (numeric(params.x1) && numeric(params.y1)) {
// 	// 		x1 = params.x1; y1 = params.y1;
// 	// 		if (numeric(params.x2) && numeric(params.y2)) { x2 = params.x2; y2 = params.y2; }
// 	// 		//else if // 点角方式
// 	// 		else console.warn('不支持的绘制直线方式');
// 	// 	}
// 	// 	_reset(shape, params).moveTo(x1, y1);
// 	// 	shape.graphics.lineTo(x2, y2);
// 	// 	shape.graphics.endFill();
// 	// 	return shape;
// 	// }

// 	/**
// 	 * 创建或者重置多边形
// 	 * @param params 创建或者重置参数
// 	 * @param convex 重置直线绘图
// 	 * @return 创建或者重置结果
// 	 */
// 	export function _drawConvex(params: hjc.TDraw, convex?: egret.Shape): egret.Shape {
// 		let shape = null;
// 		if (convex) {
// 			shape = convex;
// 			shape.graphics.clear();
// 		} else shape = new egret.Shape();
// 		if (notEmptyArr(params.vertices)) {
// 			let head = params.vertices.head();
// 			_reset(shape, params).moveTo(head[0], head[1]);
// 			for (let i = 1; i < params.vertices.length; i++) {
// 				shape.graphics.lineTo(params.vertices[i][0], params.vertices[i][1]);
// 			}
// 			shape.graphics.lineTo(head[0], head[1]);
// 		} else if (Math.isPosInt(params.verNum) && Math.isPositive(params.radius)) {
// 			let [angle, r] = [2 * Math.PI / params.verNum, params.radius];
// 			let head = [0, r];
// 			_reset(shape, params).moveTo(head[0], head[1]);
// 			for (let i = 1; i < params.verNum; i++) {
// 				shape.graphics.lineTo(r * Math.cos(angle * i), r * Math.sin(angle * i));
// 			}
// 			shape.graphics.lineTo(head[0], head[1]);
// 		}
// 		else console.warn('不支持的绘制多边形方式');
// 		shape.graphics.endFill();
// 		return shape;
// 	}

// 	/**
// 	 * 重置所有矢量绘图参数
// 	 * @return:ui模块
// 	 */
// 	export function clear(): any {
// 		$fillColor = Color.Default.FILL;
// 		$lineColor = Color.Default.LINE;
// 		$fillAlpha = 1;
// 		$thickness = 1;
// 		return ui;
// 	}

// 	/**
// 	 * 创建方形网格
// 	 * @param:num {number} 网格纵行数
// 	 * @param:gap {number} 间隔宽高度
// 	 * @return:{egret.Shape}  网格
// 	 */
// 	export function newSquareGrids(num: number, gap: number): egret.Shape {
// 		return newGrids(num, num, gap, gap);
// 	}

// 	/**
// 	 * 创建网格
// 	 * @param:row_num {number} 网格行数
// 	 * @param:col_num {number} 网格列数
// 	 * @param:gird_width {number} 间隔宽度
// 	 * @param:gird_height {number} 间隔高度
// 	 * @return:{egret.Shape}  网格
// 	 */
// 	export function newGrids(row_num: number, col_num: number, gird_width: number, gird_height: number): egret.Shape {
// 		let grids = new egret.Shape();
// 		grids.graphics.lineStyle($thickness, $lineColor, $lineAlpha);
// 		let [width, height] = [col_num * gird_height, row_num * gird_width];
// 		for (let row = 0; row <= row_num; row++) {
// 			grids.graphics.moveTo(0, row * gird_height);
// 			grids.graphics.lineTo(width, row * gird_height);
// 			grids.graphics.endFill();
// 		}
// 		for (let col = 0; col <= col_num; col++) {
// 			grids.graphics.moveTo(col * gird_width, 0);
// 			grids.graphics.lineTo(col * gird_width, height);
// 			grids.graphics.endFill();
// 		}
// 		return grids;
// 	}


// 	let $fillColor: number = Color.Default.FILL;	//(当前绘图)填充颜色
// 	let $lineColor: number = Color.Default.LINE;	//(当前绘图)线条颜色
// 	let $fillAlpha: number = 1;							//(当前绘图)填充透明度
// 	let $lineAlpha: number = 1;							//(当前绘图)线条透明度
// 	let $thickness: number = 1;							//(当前绘图)线条粗细
// 	let $p1: number[];
// 	let $p2: number[];
// 	function _renew(exist?: egret.Shape): egret.Shape {
// 		if (exist instanceof egret.Shape) { exist.graphics.clear(); return exist; }
// 		else return new egret.Shape();
// 	}
// 	// function _clearPoints(): void { $p1 = null; $p2 = null; }
// 	function _resetLine(options: hjc.DrawOptions, exist?: egret.Shape): egret.Shape {
// 		let line = _renew(exist);
// 		line.graphics.lineStyle(numeric(options.thickness) ? options.thickness : $thickness,
// 			numeric(options.lineColor) ? options.lineColor : $lineColor,
// 			numeric(options.lineAlpha) ? options.lineAlpha : $lineAlpha);
// 		return line;
// 	}
// 	function _resetFill(options: hjc.DrawOptions, exist?: egret.Shape): egret.Shape {
// 		let filled = _renew(exist);
// 		filled.graphics.beginFill(numeric(options.fillColor) ? options.fillColor : $fillColor,
// 			numeric(options.fillAlpha) ? options.fillAlpha : $fillAlpha);
// 		return filled;
// 	}
// 	function _drawLines(shape: egret.Shape, ...ps: number[][]): egret.Shape {
// 		[...ps].forEach((p: number[], i: number) => {
// 			if (i <= 0) shape.graphics.moveTo(p[0], p[1]);
// 			else shape.graphics.lineTo(p[0], p[1]);
// 		});
// 		shape.graphics.endFill();
// 		return shape;
// 	}
// 	function _pExist(options: hjc.DrawOptions): boolean {
// 		$p1 = null;
// 		if (options.point instanceof egret.Point) $p1 = [options.point.x, options.point.y];
// 		else if (numeric(options.x) && numeric(options.y)) $p1 = [options.x, options.y];
// 		return notEmpty($p1);
// 	}
// 	function _p2Exist(options: hjc.DrawOptions): boolean {
// 		$p2 = null;
// 		if (options.point2 instanceof egret.Point) $p2 = [options.point2.x, options.point2.y];
// 		else if (numeric(options.x2) && numeric(options.y2)) $p2 = [options.x2, options.y2];
// 		return notEmpty($p2);
// 	}

// 	/** (重新)绘制直(折)线 */
// 	export function drawLine(options: hjc.DrawOptions, line?: egret.Shape): egret.Shape {
// 		let _line = _resetLine(options, line);
// 		//多点式(points|xys)
// 		if (notEmptyArr(options.points) && options.points.length >= 2) return _drawLines(_line, ...options.points.map(p => [p.x, p.y]));
// 		else if (notEmptyArr(options.xys) && options.xys.length >= 2) return _drawLines(_line, ...options.xys);
// 		//点角线式(point|xy + angle + length)
// 		if (_pExist(options) && numeric(options.angle) && numeric(options.length)) {
// 			$p2 = [$p1[0] + Math.sin(options.angle) * options.length, $p1[1] + Math.cos(options.angle) * options.length];
// 			return _drawLines(_line, $p1, $p2);
// 		}
// 		//两点式(point|xy + point2|xy2)
// 		if (_p2Exist(options)) return _drawLines(_line, $p1, $p2);
// 		else console.warn('hjc不支持的绘制直(折)线方式');
// 		return line ? line : null;
// 	}

// 	/** (重新)绘制曲线 */
// 	export function drawCurve(options: hjc.DrawOptions, curve?: egret.Shape): egret.Shape {
// 		let _curve = _resetLine(options, curve);
// 		console.warn('hjc不支持的绘制曲线方式');
// 		return curve ? curve : null;
// 	}

// 	/** 
// 	 * (重新)绘制弧线
// 	 * @param options 绘制参数
// 	 * @description options={
// 	 * 		x&y:绘制圆心坐标,
// 	 * 		point:绘制圆心坐标,
// 	 * 		radius:绘制半径,
// 	 * 		angle:绘制弧长
// 	 * 		angleFrom:绘制弧起点角度,
// 	 * 		angleTo:绘制弧终点角度,
// 	 * 		anticlockwise:逆时针绘弧,
// 	 * }
// 	 * @param arc 重新绘制而非新建
// 	 * @return (重新)绘制的弧线
// 	 **/
// 	export function drawArc(options: hjc.DrawOptions, arc?: egret.Shape): egret.Shape {
// 		if (!_pExist(options)) $p1 = [0, 0];
// 		if (numeric(options.radius)) {
// 			if (numeric(options.angle) || numeric(options.angleTo)) {
// 				let _arc = _resetLine(options, arc);
// 				let startAngle = Math.angleToRadian(numeric(options.angleFrom) ? options.angleFrom : 0);
// 				let endAngle = Math.angleToRadian(numeric(options.angleTo) ? options.angleTo : (startAngle + options.angle));
// 				_arc.graphics.drawArc($p1[0], $p1[1], options.radius, startAngle, endAngle, !!options.anticlockwise);
// 				_arc.graphics.endFill();
// 				return _arc;
// 			} else console.warn('hjc drawArc require param: "angle" or "angleTo"');
// 		} else console.warn('hjc drawArc require param: "radius"');
// 		return !!arc ? arc : null;
// 	}

// 	/** (重新)绘制网格线 */
// 	export function drawGrids(options: hjc.DrawOptions, grids?: egret.Shape): egret.Shape {
// 		let _grids = _resetLine(options, grids);
// 		let [colNum, rowNum, gw, gh] = [0, 0, 0, 0];
// 		if (Math.isPosInt(options.colNum) && Math.isPosInt(options.rowNum)) {
// 			colNum = options.colNum; rowNum = options.rowNum;
// 		} else { hjc.require('ui.drawGrids', 'positive int', 'colNum', 'rowNum'); return null; }
// 		if (Math.isPositive(options.gridSize)) { gw = options.gridSize; gh = options.gridSize; }
// 		if (Math.isPositive(options.gridWidth)) gw = options.gridWidth;
// 		if (Math.isPositive(options.gridHeight)) gh = options.gridHeight;
// 		if (!Math.isPositive(gw) || !Math.isPositive(gh)) {
// 			hjc.require('ui.drawGrids', 'positive number', 'girdSize', 'girdsWidth/Height');
// 			return grids;
// 		}
// 		let [w, h] = [colNum * gw, rowNum * gh];
// 		for (let row = 0; row <= rowNum; row++) { _drawLines(_grids, [0, row * gh], [w, row * gh]); }
// 		for (let col = 0; col <= colNum; col++) { _drawLines(_grids, [col * gw, 0], [col * gw, h]); }
// 		return _grids;
// 	}

// 	/** (重新)绘制扇形 */
// 	export function drawSector(options: hjc.DrawOptions, sector?: egret.Shape): egret.Shape {
// 		let _sector = _resetFill(options, _resetLine(options, sector));
// 		console.warn('hjc不支持的绘制扇形方式');
// 		return sector ? sector : null;
// 	}

// 	/** (重新)绘制拱形 */
// 	export function drawArch(options: hjc.DrawOptions, arch?: egret.Shape): egret.Shape {
// 		let _arch = _resetFill(options, _resetLine(options, arch));
// 		console.warn('hjc不支持的绘制拱形方式');
// 		return arch ? arch : null;
// 	}

// 	/** (重新)绘制矩形 */
// 	export function drawRect(options: hjc.DrawOptions, rect?: egret.Shape): egret.Shape {
// 		let _rect = _resetFill(options, _resetLine(options, rect));
// 		console.warn('hjc不支持的绘制矩形方式');
// 		return rect ? rect : null;
// 	}

// 	/** (重新)绘制圆形 */
// 	export function drawCircle(options: hjc.DrawOptions, circle?: egret.Shape): egret.Shape {
// 		let _circle = _resetFill(options, _resetLine(options, circle));
// 		console.warn('hjc不支持的绘制圆形方式');
// 		return circle ? circle : null;
// 	}

// 	/** (重新)绘制椭圆形 */
// 	export function drawEllipse(options: hjc.DrawOptions, ellipse?: egret.Shape): egret.Shape {
// 		let _ellipse = _resetFill(options, _resetLine(options, ellipse));
// 		console.warn('hjc不支持的绘制椭圆形方式');
// 		return ellipse ? ellipse : null;
// 	}

// 	/** (重新)绘制多边形 */
// 	export function drawPolygon(options: hjc.DrawOptions, polygon?: egret.Shape): egret.Shape {
// 		let _polygon = _resetFill(options, _resetLine(options, polygon));
// 		console.warn('hjc不支持的绘制多边形方式');
// 		return polygon ? polygon : null;
// 	}

// 	/** (重新)绘制胶囊体 */
// 	export function drawCapsule(options: hjc.DrawOptions, capsule?: egret.Shape): egret.Shape {
// 		let _capsule = _resetFill(options, _resetLine(options, capsule));
// 		console.warn('hjc不支持的绘制多边形方式');
// 		return capsule ? capsule : null;
// 	}
// }

// function gtest(): void {
// 	ui.resetLineColor(Color.RED).resetThinkness(5);
// 	let point = new egret.Point(200, 200);
// 	let point2 = new egret.Point(400, 200);
// 	this.addChild(ui.drawLine({ point, point2 }));
// 	this.addChild(ui.drawLine({ point, x2: 200, y2: 400 }));
// 	this.addChild(ui.drawLine({ x: 200, y: 400, x2: 400, y2: 400 }));
// 	this.addChild(ui.drawLine({ x: 400, y: 400, point2 }));

// 	ui.resetLineColor(Color.GREEN);
// 	let arr = [];
// 	Array.nature(200, 400, 20).forEach(x => arr.push([x, 500], [x, 900]));
// 	this.addChild(ui.drawLine({ xys: arr }));
// }